#define _CRT_SECURE_NO_WARNINGS
#include <string>
#include "myString.h"

// ����������� ������������.
MyString::MyString(const char* Str)
{
	if (Str != nullptr)
	{
		m_pStr = new char[strlen(Str) + 1];
		strcpy_s(m_pStr, strlen(Str) + 1, Str);
	}
	else { m_pStr = nullptr; }
	
}

MyString::MyString(const char* Str, int size)
{
	if (Str != nullptr)
	{
	m_pStr = new char[size];
	strcpy_s(m_pStr, strlen(Str) + 1, Str);
	}
	else { m_pStr = nullptr; }
}

//����� , ������� ��������� ������ � ���������� ������
const char* MyString::GetString() const
{
	return m_pStr;
}

//����������� �����������
MyString::MyString(const MyString& Other)
{
	//��� ������� ����������, ���� � ���-�� ������????
	//delete[] m_pStr; 
	m_pStr = new char[strlen(Other.m_pStr) + 1];
	strcpy_s(m_pStr, strlen(Other.m_pStr) + 1, Other.m_pStr);
}

//������������ ����������� �����������
MyString::MyString(MyString&& Other)
{
	m_pStr = Other.m_pStr; //������ �������� ������ (��������)
	Other.m_pStr = nullptr;//�������, ��� � ������� ��� (������ ��� �������)
}

// ����������� �����������.
MyString::~MyString()
{
	//to_do m_pStr = new char [strlen(Str) + 1];
	delete[] m_pStr;
	m_pStr = nullptr;
}

//operator+
MyString MyString::operator+(const MyString& other) const
{
	MyString tmp_Str(m_pStr, strlen(m_pStr) + strlen(other.m_pStr) + 1);
	strcat(tmp_Str.m_pStr, other.m_pStr);
	
	return tmp_Str;//������������ �����������	
}

//�������� ������������ ����������� �����
MyString& MyString::operator=(const MyString& Other)
{
	if (&Other != this)
	{
		delete[] m_pStr;//����� �� ��������������?
		m_pStr = new char[strlen(Other.m_pStr) + 1];
		strcpy_s(m_pStr, strlen(Other.m_pStr) + 1, Other.m_pStr);
	}
	
	return *this;
}


//operator+=
MyString& MyString::operator+=(const MyString& other)
{
	if (&other != nullptr)
	{
		MyString tmp_Str(m_pStr, strlen(m_pStr) + strlen(other.m_pStr) + 1);
		strcat(tmp_Str.m_pStr, other.m_pStr);
		
		delete[] m_pStr;
		m_pStr = tmp_Str.m_pStr; //������ �������� ������ (��������)
		tmp_Str.m_pStr = nullptr;
	}

	return *this;
}


//������������ �������� ������������
void MyString::operator=(MyString&& Other)
{	

	delete[] m_pStr;

	m_pStr = Other.m_pStr; //������ �������� ������ (��������)
	Other.m_pStr = nullptr;//�������, ��� � ������� ��� (������ ��� �������)
}

MyString& MyString::operator=(const char* Str)
{	
	if (Str != nullptr)
	{
		if (strlen(m_pStr) != strlen(Str))
		{
			delete[] m_pStr;
			m_pStr = new char[strlen(Str) + 1];
		}

		strcpy_s(m_pStr, strlen(Str) + 1, Str);
	}

	return *this;
}

//�����, ������� ����� �������� ������ �� �����
void MyString::SetNewString(const char* Str)
{
	//if (strlen(m_pStr) >= strlen(Str)) {}; ����� �� ��������???
	if (strcmp(m_pStr, Str))
	{
		if (strlen(m_pStr) != strlen(Str)) 
		{
			delete[] m_pStr;
			m_pStr = new char[strlen(Str) + 1];
		};
		
		strcpy_s(m_pStr, strlen(Str) + 1, Str);
	}	
}

std::ostream& operator<<(std::ostream& os, const MyString& str)
{
	os << /*"contents: \"" << */str.m_pStr /*<< "\"" << std::endl*/;
	return os;
}

MyString concatenation(const char* Str, ...)
{	
	size_t size = 1;

	for (const char** p = &Str; *(p) != nullptr; p++)
	{
		size +=strlen(*p);
	}
	
	char* tmp_Str = new char [size] {};

	for (const char** p = &Str; *(p) != nullptr; p++)
	{
		tmp_Str = strcat(tmp_Str, *p);		
	}
	
	MyString tmp (tmp_Str);
	delete[]tmp_Str;//��� ������ ������

	return tmp;//������������ �����������
}
